package com.bwie.system.producer;

import com.bwie.common.domain.Data1;
import com.bwie.common.domain.Data2;
import com.bwie.common.domain.Data3;

import java.io.*;
import java.nio.file.Files;
import java.util.Base64;

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.SimpleDateFormat;

import java.util.Date;


import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @ClassName:
 * @Description:
 * @Author: zengfanzhen
 */
import org.springframework.stereotype.Component;


import org.springframework.web.bind.annotation.RestController;

import java.util.Date;
import java.util.Random;
import java.util.UUID;

import static org.apache.tomcat.util.buf.ByteChunk.convertToBytes;


@RestController
@Component
@Slf4j
public class DataProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    ObjectMapper objectMapper = new ObjectMapper();


    // 发送数据1到队列
    public void sendData1() {
        Data1 data1 = generateRandomData1();
        String jsonData;
        try {
            jsonData = objectMapper.writeValueAsString(data1); // 将 Data1 对象转换为 JSON 字符串
            String messageId = UUID.randomUUID().toString(); // 生成唯一的消息ID
            rabbitTemplate.convertAndSend("dandong", "data1", jsonData, message -> {
                message.getMessageProperties().setMessageId(messageId); // 设置消息的唯一标识符
                return message;
            });
        } catch (JsonProcessingException e) {
            log.error("转换为JSON字符串时出错: {}", e.getMessage());
        }
    }

    // 发送数据2到队列
    public void sendData2() {
        Data2 data2 = generateRandomData2(); // 使用生成器生成随机的Data2对象
        String jsonData;
        try {
            jsonData = objectMapper.writeValueAsString(data2); // 将 Data2 对象转换为 JSON 字符串
            String messageId = UUID.randomUUID().toString(); // 生成唯一的消息ID
            rabbitTemplate.convertAndSend("dandong", "data2", jsonData, message -> {
                message.getMessageProperties().setMessageId(messageId); // 设置消息的唯一标识符
                return message;
            });
        } catch (JsonProcessingException e) {
            log.error("转换为JSON字符串时出错: {}", e.getMessage());
        }
    }

    // 发送数据3到队列
    public void sendData3() {
        Data3 data3 = generateRandomData3();
        String jsonData;
        try {
            jsonData = objectMapper.writeValueAsString(data3); // 将 Data3 对象转换为 JSON 字符串
            String messageId = UUID.randomUUID().toString(); // 生成唯一的消息ID
            rabbitTemplate.convertAndSend("dandong", "data3", jsonData, message -> {
                message.getMessageProperties().setMessageId(messageId); // 设置消息的唯一标识符
                return message;
            });
        } catch (JsonProcessingException e) {
            log.error("转换为JSON字符串时出错: {}", e.getMessage());
        }
    }


    // 生成随机的Data1对象
    private Data1 generateRandomData1() {
        Data1 data1 = new Data1();
        data1.setId(UUID.randomUUID().toString()); // 随机生成UUID作为编号
        data1.setXM(generateRandomName()); // 随机生成姓名
        data1.setCard(generateRandomCard()); // 随机生成证件号
        data1.setAge(generateRandomAge()); // 随机生成年龄
        data1.setTime(generateRandomDateTime()); // 随机生成日期时间
        return data1;
    }

    // 随机生成 Data2 对象
    public Data2 generateRandomData2() {
        Data2 data2 = new Data2();
        data2.setId(UUID.randomUUID().toString()); // 随机生成 UUID 作为编号
        data2.setXM(generateRandomName()); // 随机生成姓名
        data2.setCard(generateRandomCard()); // 随机生成证件号
        data2.setPhoto1(getRandomImageAsBase64()); // 随机生成证件照片的 Base64 数据
        data2.setPhoto2(getRandomImageAsBase64()); // 随机生成采集照片的 Base64 数据
        System.out.println(getRandomImageAsBase64());
        return data2;
    }

    // 随机生成 Data3 对象
    public Data3 generateRandomData3() {
        Data3 data3 = new Data3();
        data3.setId(UUID.randomUUID().toString()); // 随机生成 UUID 作为编号
        data3.setPlate(generateRandomPlate()); // 随机生成车牌号
        data3.setTime(generateRandomDateTime()); // 随机生成日期时间
        return data3;
    }

    // 随机生成姓名
    private String generateRandomName() {
        String[] names = {"张三", "李四", "王五", "赵六", "钱七", "孙八", "周九", "吴十"};
        return names[(int) (Math.random() * names.length)];
    }

    // 随机生成证件号
    private String generateRandomCard() {
        // 生成一个18位的随机数字字符串作为证件号
        StringBuilder card = new StringBuilder();
        for (int i = 0; i < 18; i++) {
            card.append((int) (Math.random() * 10));
        }
        return card.toString();
    }

    public static void main(String[] args) {
        byte[] base64Image = getRandomImageAsBase64();
        // Base64格式的图片数据
        try {

            // 生成图片文件名
            String imageName = generateImageName();

            // 将字节数组写入图片文件
            String imagePath = "D:\\images\\" + imageName; // 保存图片的路径
            writeImageToFile(base64Image, imagePath);
            System.out.println("图片已成功保存到：" + imagePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 生成图片文件名
    private static String generateImageName() {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd_HHmmss");
        return "image_" + dateFormat.format(new Date()) + ".jpg";
    }

    // 将Base64字符串转换为字节数组
    private static byte[] convertToBytes(String base64Image) {
        return Base64.getDecoder().decode(base64Image);
    }

    // 将字节数组写入图片文件
    private static void writeImageToFile(byte[] imageData, String imagePath) throws IOException {
        Path path = Paths.get(imagePath);
        try (FileOutputStream fos = new FileOutputStream(path.toFile())) {
            fos.write(imageData);
        }
    }


    // 从本地图片文件读取数据并转换为Base64格式
    private static byte[] getRandomImageAsBase64() {
        try {
            // 构建文件对象
            File folder = new File("D:\\images");

            // 获取文件夹下的所有文件列表
            File[] files = folder.listFiles();

            // 如果文件夹为空或者没有图片文件，则返回空
            if (files == null || files.length == 0) {
                return null;
            }

            // 随机选择一张图片文件
            Random random = new Random();
            File randomFile = files[random.nextInt(files.length)];

            // 读取图片文件的所有字节数据并返回
            return Files.readAllBytes(randomFile.toPath());
        } catch (IOException e) {
            // 打印异常堆栈信息
            e.printStackTrace();
            return null;
        }
    }

    // 生成随机的年龄
    private int generateRandomAge() {
        // 随机生成一个18到60之间的年龄
        return new Random().nextInt(43) + 18;
    }

    // 生成随机的日期时间
    private Date generateRandomDateTime() {
        // 随机生成一个2020年到2024年之间的日期时间
        long millis = new Random().nextLong() % (5L * 365 * 24 * 3600 * 1000) + new Date().getTime();
        return new Date(millis);
    }

    // 随机生成车牌号
    private String generateRandomPlate() {
        // 生成一个长度为7的随机车牌号，以"苏"开头，后面接6位数字
        StringBuilder plate = new StringBuilder("苏");
        for (int i = 0; i < 6; i++) {
            plate.append((int) (Math.random() * 10));
        }
        return plate.toString();
    }


}




